package ali;

/*
 * @Author: qianmingtian
 * @Date: 2020-05-29 11:11:08
 * @LastEditors: qianmingtian
 * @LastEditTime: 2020-05-29 15:45:03
 * @FilePath: \qianmingtian.github.io\code\ali\Main.java
 */ 
// package junQiAli88.minCost;

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int count = sc.nextInt();
        for (int i = 0; i < count; i ++) {
            long n = sc.nextInt();
            long m = sc.nextInt();
            int w2 = sc.nextInt();
            int w3 = sc.nextInt();
            int cost = 0;
            if (n >= m) {
                System.out.println(0);
            }else{
                // 假定一个特殊情况，w3 < w2，及乘3的代价比乘2还小，那么一直乘3就可以
                if (w3 < w2) {
                    while (n < m) {
                        n  = n * 3;
                        cost += w3;
                    }
                    System.out.println(cost);
                    return;
                }
                // 正常情况下，w3 > w2
                double r2 = w2 >> 1; // 乘2的平均代价
                double r3 = w3 / 3; // 乘3的平均代价
                boolean flag = (r2 >= r3);
                while(n < m){
                    // 如果两步到不了，选性价比最好的
                    if ((n * 9) < m) {
                        if (flag) {
                            n = n * 3;
                            cost += w3;
                            continue;
                        } else {
                            n = n * 2;
                            cost += w2;
                            continue;
                        }
                    }
                    // 下面是两步可达的情况，分情况讨论

                    // *2可达，就*2
                    if ((n << 1) >= m) {
                        cost += (w2 <= w3 ? w2 : w3);
                        System.out.println(cost);
                        break;
                    }
                    // 如果*2不可达，*3可达，则*4必然可达； 比较 w3 和 2*w2，选最小的;
                    if ((n * 3) >= m) {
                        cost += (w3 <= (w2 * 2) ? w3 : (w2 * 2));
                        System.out.println(cost);
                        break;
                    }

                    // 如果*3不可达，*4可达，则*6必然可达； 比较 2 * w2 和 w2 + w3，选最小的；
                    if ((n << 2) >= m) {
                        cost += ((2 * w2) <= (w2 + w3) ? (2 * w2) : (w2 + w3));
                        System.out.println(cost);
                        break;
                    }

                    // 如果*4不可达，*6可达，则*8必然可达； 比较w2 + w3 和 3 * w2，选最小的；
                    if ((n * 6) >= m) {
                        cost += (w2 + w3) <= (3 * w2) ? (w2 + w3) : (3 * w2);
                        System.out.println(cost);
                        break;
                    }

                    // 如果*6不可达，*8可达，则*9必然可达； 比较 3 * w2 和 2 * w3，选最小的；
                    if ((n << 3) >= m) {
                        cost += (3 * w2) <= (2 * w3) ? (3 * w2) : (2 * w3);
                        System.out.println(cost);
                        break;
                    }

                    // 如果*8不可达，*9可达，则*12和16必然可达； 比较 2 * w3 、 4 * w2 和 (2 * w2 + w3)，选最小的
                    if ((n * 9) >= m) {
                        if (w3 >= 2 * w2) {
                            cost += 4 * w2;
                        } else {
                            cost += 2 * w3;
                        }
                        System.out.println(cost);
                        break;
                    }
                }
            }

        }
        sc.close();
    }
}
